{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Emotion Classification in texts using LSTM and Word2Vec\n",
    "\n",
    "### Architecture: \n",
    "(X) Text -> Embedding (W2V pretrained on wikipedia articles) -> Deep Network (LSTM/GRU) -> Fully connected (Dense) -> Output Layer (Softmax) -> Emotion class (Y)\n",
    "\n",
    "#### Embedding Layer\n",
    "* Word Embedding is a representation of text where words that have the similar meaning have a similar representation. We will use 300 dimentional word vectors pre-trained on wikipedia articles. We can also train the w2v model with our data, however our dataset is quite small and trained word vectors might not be as good as using pretrained w2v.\n",
    "\n",
    "#### Deep Network\n",
    "* Deep network takes the sequence of embedding vectors as input and converts them to a compressed representation. The compressed representation effectively captures all the information in the sequence of words in the text. The deep network part is usually an RNN or some forms of it like LSTM/GRU. The dropout can be added to overcome the tendency to overfit, a very common problem with RNN based networks.\n",
    "\n",
    "#### Fully Connected Layer\n",
    "* The fully connected layer takes the deep representation from the RNN/LSTM/GRU and transforms it into the final output classes or class scores. This component is comprised of fully connected layers along with batch normalization and optionally dropout layers for regularization.\n",
    "\n",
    "#### Output Layer\n",
    "* Based on the problem at hand, this layer can have either Sigmoid for binary classification or Softmax for both binary and multi classification output."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Workflow: \n",
    "1. Import Data\n",
    "2. Prepare the input data\n",
    "3. Import pre-trained W2V\n",
    "4. Create Neural Network Pipeline\n",
    "5. Train The Model\n",
    "6. Evaluate results\n",
    "\n",
    "\n",
    "\n",
    "👋  **Let's start** "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Import Data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# text preprocessing\n",
    "from nltk.tokenize import word_tokenize\n",
    "import re\n",
    "\n",
    "# plots and metrics\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import accuracy_score, f1_score, confusion_matrix\n",
    "\n",
    "# preparing input to our model\n",
    "from keras.preprocessing.text import Tokenizer\n",
    "from keras.preprocessing.sequence import pad_sequences\n",
    "from keras.utils import to_categorical\n",
    "\n",
    "# keras layers\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Embedding, Bidirectional, LSTM, GRU, Dense"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Defining vector space dimension and fixed input size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Number of labels: joy, anger, fear, sadness, neutral\n",
    "num_classes = 5\n",
    "\n",
    "# Number of dimensions for word embedding\n",
    "embed_num_dims = 300\n",
    "\n",
    "# Max input length (max number of words) \n",
    "max_seq_len = 500\n",
    "\n",
    "class_names = ['joy', 'fear', 'anger', 'sadness', 'neutral']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Importing our training and testing datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_train = pd.read_csv('data/data_train.csv', encoding='utf-8')\n",
    "data_test = pd.read_csv('data/data_test.csv', encoding='utf-8')\n",
    "\n",
    "X_train = data_train.Text\n",
    "X_test = data_test.Text\n",
    "\n",
    "y_train = data_train.Emotion\n",
    "y_test = data_test.Emotion\n",
    "\n",
    "data = data_train.append(data_test, ignore_index=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "joy        2326\n",
      "sadness    2317\n",
      "anger      2259\n",
      "neutral    2254\n",
      "fear       2171\n",
      "Name: Emotion, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Emotion</th>\n",
       "      <th>Text</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>neutral</td>\n",
       "      <td>There are tons of other paintings that I thin...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>sadness</td>\n",
       "      <td>Yet the dog had grown old and less capable , a...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>fear</td>\n",
       "      <td>When I get into the tube or the train without ...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>fear</td>\n",
       "      <td>This last may be a source of considerable disq...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>anger</td>\n",
       "      <td>She disliked the intimacy he showed towards so...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>sadness</td>\n",
       "      <td>When my family heard that my Mother's cousin w...</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   Emotion                                               Text\n",
       "0  neutral   There are tons of other paintings that I thin...\n",
       "1  sadness  Yet the dog had grown old and less capable , a...\n",
       "2     fear  When I get into the tube or the train without ...\n",
       "3     fear  This last may be a source of considerable disq...\n",
       "4    anger  She disliked the intimacy he showed towards so...\n",
       "5  sadness  When my family heard that my Mother's cousin w..."
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(data.Emotion.value_counts())\n",
    "data.head(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Prepare input data\n",
    "To input the data to our NN Model we'll need some preprocessing:\n",
    "1. Tokenize our texts and count unique tokens\n",
    "2. Padding: each input (sentence or text) has to be of the same lenght\n",
    "3. Labels have to be converted to integeres and categorized"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic preprocessing and tokenization using nltk to double check that sentences are properly split into words.\n",
    "We could also add stopword removal but steps like stemming or lemmatization are not needed since we are using word2vec and words with the same stem can have a different meaning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def clean_text(data):\n",
    "    \n",
    "    # remove hashtags and @usernames\n",
    "    data = re.sub(r\"(#[\\d\\w\\.]+)\", '', data)\n",
    "    data = re.sub(r\"(@[\\d\\w\\.]+)\", '', data)\n",
    "    \n",
    "    # tekenization using nltk\n",
    "    data = word_tokenize(data)\n",
    "    \n",
    "    return data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Making things easier for keras tokenizer 🙃"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "texts = [' '.join(clean_text(text)) for text in data.Text]\n",
    "\n",
    "texts_train = [' '.join(clean_text(text)) for text in X_train]\n",
    "texts_test = [' '.join(clean_text(text)) for text in X_test]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a bit ? I 'm extremely annoyed that he did n't phone me when he promised me that he would ! He 's such a liar .\n"
     ]
    }
   ],
   "source": [
    "print(texts_train[92])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tokenization + fitting using keras**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of unique words: 12087\n"
     ]
    }
   ],
   "source": [
    "tokenizer = Tokenizer()\n",
    "tokenizer.fit_on_texts(texts)\n",
    "\n",
    "sequence_train = tokenizer.texts_to_sequences(texts_train)\n",
    "sequence_test = tokenizer.texts_to_sequences(texts_test)\n",
    "\n",
    "index_of_words = tokenizer.word_index\n",
    "\n",
    "# vacab size is number of unique words + reserved 0 index for padding\n",
    "vocab_size = len(index_of_words) + 1\n",
    "\n",
    "print('Number of unique words: {}'.format(len(index_of_words)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Padding** -> each input has the same length\n",
    "\n",
    "We defined maximun number of words for our texts and input size to our model has to be fixed - padding with zeros to keep the same input lenght (longest input in our dataset is ~250 words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[    0,     0,     0, ...,   119,    51,   345],\n",
       "       [    0,     0,     0, ...,    37,   277,   154],\n",
       "       [    0,     0,     0, ...,    16,     2,  1210],\n",
       "       ...,\n",
       "       [    0,     0,     0, ...,   876,     4,   909],\n",
       "       [    0,     0,     0, ...,     1,     6,   117],\n",
       "       [    0,     0,     0, ..., 10258,   173,    13]], dtype=int32)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train_pad = pad_sequences(sequence_train, maxlen = max_seq_len )\n",
    "X_test_pad = pad_sequences(sequence_test, maxlen = max_seq_len )\n",
    "\n",
    "X_train_pad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Categorize** labels: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "encoding = {\n",
    "    'joy': 0,\n",
    "    'fear': 1,\n",
    "    'anger': 2,\n",
    "    'sadness': 3,\n",
    "    'neutral': 4\n",
    "}\n",
    "\n",
    "# Integer labels\n",
    "y_train = [encoding[x] for x in data_train.Emotion]\n",
    "y_test = [encoding[x] for x in data_test.Emotion]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 1.],\n",
       "       [0., 0., 0., 1., 0.],\n",
       "       [0., 1., 0., 0., 0.],\n",
       "       ...,\n",
       "       [0., 0., 0., 1., 0.],\n",
       "       [0., 1., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0.]], dtype=float32)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_train = to_categorical(y_train)\n",
    "y_test = to_categorical(y_test)\n",
    "\n",
    "y_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Import pretrained word vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Importing pretrained word2vec from file and creating embedding matrix\n",
    "* We will later map each word in our corpus to existing word vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_embedding_matrix(filepath, word_index, embedding_dim):\n",
    "    vocab_size = len(word_index) + 1  # Adding again 1 because of reserved 0 index\n",
    "    embedding_matrix = np.zeros((vocab_size, embedding_dim))\n",
    "    with open(filepath) as f:\n",
    "        for line in f:\n",
    "            word, *vector = line.split()\n",
    "            if word in word_index:\n",
    "                idx = word_index[word] \n",
    "                embedding_matrix[idx] = np.array(\n",
    "                    vector, dtype=np.float32)[:embedding_dim]\n",
    "    return embedding_matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can download and import any pre-trained word embeddings. I will use 300 dimentional w2v pre-trained on wikipedia articles. Download fast text english vectors: https://fasttext.cc/docs/en/english-vectors.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import urllib.request\n",
    "import zipfile\n",
    "import os\n",
    "\n",
    "fname = 'embeddings/wiki-news-300d-1M.vec'\n",
    "\n",
    "if not os.path.isfile(fname):\n",
    "    print('Downloading word vectors...')\n",
    "    urllib.request.urlretrieve('https://dl.fbaipublicfiles.com/fasttext/vectors-english/wiki-news-300d-1M.vec.zip',\n",
    "                              'wiki-news-300d-1M.vec.zip')\n",
    "    print('Unzipping...')\n",
    "    with zipfile.ZipFile('wiki-news-300d-1M.vec.zip', 'r') as zip_ref:\n",
    "        zip_ref.extractall('embeddings')\n",
    "    print('done.')\n",
    "    \n",
    "    os.remove('wiki-news-300d-1M.vec.zip')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(12088, 300)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "embedd_matrix = create_embedding_matrix(fname, index_of_words, embed_num_dims)\n",
    "embedd_matrix.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some of the words from our corpus were not included in the pre-trained word vectors. If we inspect those words we'll see that it's mostly spelling errors. It's also good to double check the noise in our data f.e different languages or tokenizer errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Words found in wiki vocab: 11442\n",
      "New words found: 645\n"
     ]
    }
   ],
   "source": [
    "# Inspect unseen words\n",
    "new_words = 0\n",
    "\n",
    "for word in index_of_words:\n",
    "    entry = embedd_matrix[index_of_words[word]]\n",
    "    if all(v == 0 for v in entry):\n",
    "        new_words = new_words + 1\n",
    "\n",
    "print('Words found in wiki vocab: ' + str(len(index_of_words) - new_words))\n",
    "print('New words found: ' + str(new_words))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Create LSTM Pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Embedding Layer\n",
    "\n",
    "We will use pre-trained word vectors. We could also train our own embedding layer if we don't specify the pre-trained weights \n",
    "\n",
    "* **vocabulary size:** the maximum number of terms that are used to represent a text: e.g. if we set the size of the “vocabulary” to 1000 only the first thousand terms most frequent in the corpus will be considered (and the other terms will be ignored)\n",
    "* **the maximum length:** of the texts (which must all be the same length)\n",
    "* **size of embeddings:** basically, the more dimensions we have the more precise the semantics will be, but beyond a certain threshold we will lose the ability of the embedding to define a coherent and general enough semantic area\n",
    "* **trainable:** True if you want to fine-tune them while training\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Embedding layer before the actaul BLSTM \n",
    "embedd_layer = Embedding(vocab_size,\n",
    "                         embed_num_dims,\n",
    "                         input_length = max_seq_len,\n",
    "                         weights = [embedd_matrix],\n",
    "                         trainable=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Model Pipeline\n",
    "- the input is the first N words of each text (with proper padding)\n",
    "- the first level creates embedding of words, using vocabulary with a certain dimension, and a given size of embeddings\n",
    "- LSTM/GRU layer which will receive word embeddings for each token in the tweet as inputs. The intuition is that its output tokens will store information not only of the initial token, but also any previous tokens; In other words, the LSTM layer is generating a new encoding for the original input.\n",
    "- the output level has a number of neurons equal to the classes of the problem and a “softmax” activation function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change GRU to LSTM. The results will be very similar but LSTM might take longer to train."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters\n",
    "gru_output_size = 128\n",
    "bidirectional = True\n",
    "\n",
    "# Embedding Layer, LSTM or biLSTM, Dense, softmax\n",
    "model = Sequential()\n",
    "model.add(embedd_layer)\n",
    "\n",
    "if bidirectional:\n",
    "    model.add(Bidirectional(GRU(units=gru_output_size,\n",
    "                              dropout=0.2,\n",
    "                              recurrent_dropout=0.2)))\n",
    "else:\n",
    "     model.add(GRU(units=gru_output_size,\n",
    "                dropout=0.2, \n",
    "                recurrent_dropout=0.2))\n",
    "\n",
    "model.add(Dense(num_classes, activation='softmax'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "embedding_1 (Embedding)      (None, 500, 300)          3626400   \n",
      "_________________________________________________________________\n",
      "bidirectional_2 (Bidirection (None, 256)               329472    \n",
      "_________________________________________________________________\n",
      "dense_2 (Dense)              (None, 5)                 1285      \n",
      "=================================================================\n",
      "Total params: 3,957,157\n",
      "Trainable params: 330,757\n",
      "Non-trainable params: 3,626,400\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])\n",
    "model.summary()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Train the Model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* **validation data**: use validation_split in order to estimate how well your model has been trained and adjust parameters or add dropout layers. After that we will train the model using the complete train set.\n",
    "* **epochs**: 15 **batch_size**: 128 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /anaconda3/lib/python3.7/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.cast instead.\n",
      "Train on 7934 samples, validate on 3393 samples\n",
      "Epoch 1/14\n",
      "7934/7934 [==============================] - 178s 22ms/step - loss: 1.4235 - acc: 0.3975 - val_loss: 1.2806 - val_acc: 0.4831\n",
      "Epoch 2/14\n",
      "7934/7934 [==============================] - 168s 21ms/step - loss: 1.1437 - acc: 0.5441 - val_loss: 1.0423 - val_acc: 0.6021\n",
      "Epoch 3/14\n",
      "7934/7934 [==============================] - 173s 22ms/step - loss: 0.9415 - acc: 0.6518 - val_loss: 0.8609 - val_acc: 0.6908\n",
      "Epoch 4/14\n",
      "7934/7934 [==============================] - 175s 22ms/step - loss: 0.8278 - acc: 0.6952 - val_loss: 0.8196 - val_acc: 0.6970\n",
      "Epoch 5/14\n",
      "7934/7934 [==============================] - 173s 22ms/step - loss: 0.7671 - acc: 0.7226 - val_loss: 0.7833 - val_acc: 0.7206\n",
      "Epoch 6/14\n",
      "7934/7934 [==============================] - 164s 21ms/step - loss: 0.7402 - acc: 0.7349 - val_loss: 0.7720 - val_acc: 0.7200\n",
      "Epoch 7/14\n",
      "7934/7934 [==============================] - 163s 21ms/step - loss: 0.7068 - acc: 0.7415 - val_loss: 0.7597 - val_acc: 0.7271\n",
      "Epoch 8/14\n",
      "7934/7934 [==============================] - 164s 21ms/step - loss: 0.6935 - acc: 0.7516 - val_loss: 0.7597 - val_acc: 0.7206\n",
      "Epoch 9/14\n",
      "7934/7934 [==============================] - 164s 21ms/step - loss: 0.6742 - acc: 0.7546 - val_loss: 0.7470 - val_acc: 0.7262\n",
      "Epoch 10/14\n",
      "7934/7934 [==============================] - 164s 21ms/step - loss: 0.6612 - acc: 0.7609 - val_loss: 0.7440 - val_acc: 0.7259\n",
      "Epoch 11/14\n",
      "7934/7934 [==============================] - 163s 21ms/step - loss: 0.6388 - acc: 0.7678 - val_loss: 0.7416 - val_acc: 0.7291\n",
      "Epoch 12/14\n",
      "7934/7934 [==============================] - 182s 23ms/step - loss: 0.6288 - acc: 0.7729 - val_loss: 0.7400 - val_acc: 0.7280\n",
      "Epoch 13/14\n",
      "7934/7934 [==============================] - 186s 23ms/step - loss: 0.6139 - acc: 0.7792 - val_loss: 0.7389 - val_acc: 0.7280\n",
      "Epoch 14/14\n",
      "7934/7934 [==============================] - 196s 25ms/step - loss: 0.5997 - acc: 0.7854 - val_loss: 0.7262 - val_acc: 0.7356\n"
     ]
    }
   ],
   "source": [
    "batch_size = 128\n",
    "epochs = 15\n",
    "\n",
    "hist = model.fit(X_train_pad, y_train, \n",
    "                 batch_size=batch_size,\n",
    "                 epochs=epochs,\n",
    "                 validation_data=(X_test_pad,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#  \"Accuracy\"\n",
    "plt.plot(hist.history['acc'])\n",
    "plt.plot(hist.history['val_acc'])\n",
    "plt.title('model accuracy')\n",
    "plt.ylabel('accuracy')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'validation'], loc='upper left')\n",
    "plt.show()\n",
    "\n",
    "# \"Loss\"\n",
    "plt.plot(hist.history['loss'])\n",
    "plt.plot(hist.history['val_loss'])\n",
    "plt.title('model loss')\n",
    "plt.ylabel('loss')\n",
    "plt.xlabel('epoch')\n",
    "plt.legend(['train', 'validation'], loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = model.predict(X_test_pad)\n",
    "predictions = np.argmax(predictions, axis=1)\n",
    "predictions = [class_names[pred] for pred in predictions]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 73.56%\n",
      "\n",
      "F1 Score: 73.56\n"
     ]
    }
   ],
   "source": [
    "print(\"Accuracy: {:.2f}%\".format(accuracy_score(data_test.Emotion, predictions) * 100))\n",
    "print(\"\\nF1 Score: {:.2f}\".format(f1_score(data_test.Emotion, predictions, average='micro') * 100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Plotting confusion Matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_confusion_matrix(y_true, y_pred, classes,\n",
    "                          normalize=False,\n",
    "                          title=None,\n",
    "                          cmap=plt.cm.Blues):\n",
    "    '''\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    '''\n",
    "    if not title:\n",
    "        if normalize:\n",
    "            title = 'Normalized confusion matrix'\n",
    "        else:\n",
    "            title = 'Confusion matrix, without normalization'\n",
    "\n",
    "    # Compute confusion matrix\n",
    "    cm = confusion_matrix(y_true, y_pred)\n",
    "\n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "\n",
    "    fig, ax = plt.subplots()\n",
    "    \n",
    "    # Set size\n",
    "    fig.set_size_inches(12.5, 7.5)\n",
    "    im = ax.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    ax.figure.colorbar(im, ax=ax)\n",
    "    ax.grid(False)\n",
    "    \n",
    "    # We want to show all ticks...\n",
    "    ax.set(xticks=np.arange(cm.shape[1]),\n",
    "           yticks=np.arange(cm.shape[0]),\n",
    "           # ... and label them with the respective list entries\n",
    "           xticklabels=classes, yticklabels=classes,\n",
    "           title=title,\n",
    "           ylabel='True label',\n",
    "           xlabel='Predicted label')\n",
    "\n",
    "    # Rotate the tick labels and set their alignment.\n",
    "    plt.setp(ax.get_xticklabels(), rotation=45, ha=\"right\",\n",
    "             rotation_mode=\"anchor\")\n",
    "\n",
    "    # Loop over data dimensions and create text annotations.\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i in range(cm.shape[0]):\n",
    "        for j in range(cm.shape[1]):\n",
    "            ax.text(j, i, format(cm[i, j], fmt),\n",
    "                    ha=\"center\", va=\"center\",\n",
    "                    color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "    fig.tight_layout()\n",
    "    return ax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "F1 Score: 73.56\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAIUCAYAAAC5LUA6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xd8FHX+x/HXJ1lAUSGhKCShS2+BBCkCAgJSAqggKIpiQ72zn97pnWf3zrOX8+5+3tkbXaQpgoqKitIEQSyUoCSxAAoKUrJ8f3/sEDYhTZPNZpb38/GYh5mZ785+5ptx+eTz/c6sOecQERERkYoXF+0ARERERA5XSsREREREokSJmIiIiEiUKBETERERiRIlYiIiIiJRokRMREREJEqUiInEIDO71cye935uaGY/m1l8Ob9Hppn1L89jluI9LzOzb73zqV2G4/xsZk3LM7ZoMbM1ZtYn2nGIyG+jREzkN/CSkG/N7KiwbReZ2cIohlUo59xXzrmjnXPBaMdSFmZWBXgAGOidz9bfeizv9RvKL7ryZ2ZPm9mdJbVzzrV1zi2sgJBEJAKUiIn8dgHgqrIexEL0/2LJjgOOANZEO5DKwMwC0Y5BRMpOH/4iv929wHVmllDYTjPrYWZLzGy7998eYfsWmtldZvYesAto6m2708ze94bOZplZbTN7wcx2eMdoHHaMh83sa2/fMjPrVUQcjc3MmVnAzLp7xz6w7DazTK9dnJndYGbrzWyrmU02s1phxxlnZpu8fX8prmPM7Egzu99rv93MFpnZkd6+4d5w2o/eObcOe12mmV1nZqu8100ysyPMrAXwudfsRzN7M/y8CvTrRd7Px5vZ295xtpjZpLB2zsyO936uaWbPmtn3Xrw3HUiMzWy8F/t9ZvaDmW00s8HFnHemmV3vxb/TzJ4ws+PM7FUz+8nMFphZYlj7KWb2jRfjO2bW1ts+ATgb+OOBayHs+H8ys1XATu93mjdEbGZzzez+sONPMrMni/tdiUh0KRET+e2WAguB6wru8BKYOcAjQG1CQ2pzLP+8pnHABOAYYJO37UxvezLQDPgAeAqoBawFbgl7/RIg1dv3IjDFzI4oLmDn3AfesNzRQCKwGHjJ230lcCpwEpAE/AA85p1PG+DfXmxJ3jmlFPNW9wFpQA8vvj8C+72E6iXgaqAuMBeYZWZVw147GhgENAE6AOOdc18Abb39Cc65fsWdp+cO4HXvPFOAR4to9yhQE2jqnfu5wPlh+7sSSgLrAPcAT5iZFfO+I4EBQAtgGPAq8Gfv9XGE+vmAV4HmwLHAcuAFAOfc497P93i/r2FhrzkLGEqoH3ILvPcFwDgz62dmZwNdKIeqrYhEjhIxkbK5GbjCzOoW2D4U+NI595xzLtc59xLwGaF/mA942jm3xtu/z9v2lHNuvXNuO6F/pNc75xZ4/+BOATodeLFz7nnn3Fbv9fcD1YCWvyL2R4CdwIHq1iXAX5xzm51ze4BbgVFexWkUMNs5946376/A/sIO6lWTLgCucs5lOeeCzrn3vdeNAeY45+Z753wfcCShhC0vLudctnNuGzCLULL5W+wDGgFJzrndzrlFhcQa78V0o3PuJ+dcJnA/oYTzgE3Ouf96c+yeAeoTGiYtyqPOuW+dc1nAu8CHzrkV3vm/TP7f4ZPe+x7o745mVrOE83rEOfe1c+6Xgjucc98Al3pxPgyc65z7qYTjiUgUKRETKQPn3GpgNnBDgV1JHKxyHbCJUKXrgK8LOeS3YT//Usj60QdWzOwPZrbWG9b6kVBVp05p4jazS4A+wFjn3IGEqhHwsjdk+COhClyQUNKRFB6vc24nUNRk+TqE5nKtL2Rfvn7x3vtr8vfLN2E/7yLsnH+lPwIGfOQNhV5QRKxVyf+7Kvh7yovHObfL+7G4mEr1OzSzeDO72xsK3gFkhsVUnMKum3CzgXjg88KSTxGpXJSIiZTdLcDF5P/HO5tQYhOuIZAVtu5+6xt688H+RGgYL9E5lwBsJ5R4lOa1dwAjvMrbAV8Dg51zCWHLEV5lJwdoEHaM6oSGJwuzBdhNaGi1oHz94g3xNSB/v5TWTu+/1cO21Tvwg3PuG+fcxc65JELVvn8dmBdWINYDlbMDCv6eImUsMALoTyiJbuxtP/A7LOr6KOm6uYtQEl3fzM4qY4wiEmFKxETKyDm3DphE/rk/c4EWZjbWm1A9BmhDqFpRHo4BcoHvgYCZ3QzUKOlFZtbAi/Vcb95VuP8Ad5lZI69tXTMb4e2bCmSYWU9vPtftFPH54VW5ngQeMLMkr/LT3cyqAZOBoWZ2soUeR/EHYA/w/q86+9D7fE8oYTrHe48LCEv+zOwMMzswj+0HQglMsMAxgl5Md5nZMd65Xws8/2vj+Q2OIXTuWwklk38rsP9bQvPWSs3MehOa33autzxqZsnFv0pEokmJmEj5uB3Ie6aY94yrDEKJxlZCw2QZzrkt5fR+8wjNIfuC0FDabkoesgI4mVDVaKodvHPywOMgHgZmAq+b2U+EJvJ39c5nDfB7QjcF5BBKbDYX8z7XAZ8QuqFgG/APIM459zlwDqEJ8lsIzZkb5pzbW8rzLuhi4HpCfdyW/AldF+BDM/vZO6+rnHMbCznGFYSqaxuARd45VsSdhs8S+t1lAZ8S6u9wTwBtvKHiGSUdzMxqeMe83Jubt8g7xlMl3FwgIlFkzv3m0RERERERKQNVxERERESiRImYiIiISJQoERMRERGJEiViIiIiIlGiL40thFU92tmRtUpuKL9Zh2YFH0Qv4j+610liwddfbWLb1i2+ubM2vkYj53IP+WKJcuF++X6ec25QRA5eBCVihbAja1Gt5/XRDiOmzZ94abRDiHnxcb75XPWtfUFlYhVhvzLeiBrUp3u0Q/hVXO4vVGs5OiLH3v3xY6X6dpLypKFJERERkShRRUxERER8xMBip46kRExERET8w4AY+rKI2EkpRURERHxGFTERERHxlxgamoydMxERERHxGVXERERExF80R0xEREREykoVMREREfERPb5CREREJHo0NCkiIiIiZaWKmIiIiPiHEVNDk7FzJiIiIiI+o4qYiIiI+IhpjpiIiIiIlJ0qYiIiIuIvMTRHTImYiIiI+IuGJkVERESkrFQRExERER+JrSfrx86ZiIiIiPiMKmIiIiLiH4bmiImIiIhI2akiJiIiIv4SQ3PElIiJiIiIj2iyvoiIiIiUA1XERERExF/iNFlfRERERMpIFTERERHxDyOm5ogpERMRERF/0XPERERERKSsVBETERERH9HjK0RERESkHKgiJiIiIv6iOWIiIiIiUlaqiImIiIi/xNAcMSViIiIi4h9mGpoUERERkbJTRUxERET8JYaGJmPnTERERER8RolYJTcgrSEr/+8cVv93HNedkXbI/nsu7sniR89k8aNnsurxc8iZNCFv3yu3Dydn0gSm3ZJRkSH7zpvz59G9c1tO6NiaRx6455D9e/bs4eLxYzmhY2sG9T2RrzZlAjB10ov0PTE9bzmuZjU+WfVxBUfvD2/Mn8cJndqS3qEVD91feB9feO5Y0ju0YkCfHnl9DLBm9SpO6deTHukd6XlCKrt3767AyP3jzQXzODGtLd1SW/NoEdfxhPFj6ZbamsH9Dl7H+/bt44pLL6BP90706tKeR+7/RwVH7h9vLZhHz/R29OjUmkcfvPeQ/Xv27OGS88+mR6fWDD25J197fbx3716u/t3F9OvRmf4npvP+u29XcOQx6MA8sfJeoiAmEjEzez/aMURCXJzx0GV9GHHLTDpd9gJn9G5BqwaJ+dr88b+L6HbFRLpdMZF/z1rFK++vz9v34LTlXHj/6xUdtq8Eg0H+9IereGnaLBYtWcn0qZP4/LNP87V54dmnqJmQyEcr13LJ76/kjlv+DMCoMWN5672lvPXeUh57/CkaNGpM+w6p0TiNSi0YDPLHa69k8vRZvL90FdOnTOSztfn7+PlnniQhIYGlqz7jst9fxW1/DfVxbm4ul154Hvc//BjvL13JzFffoEqVKtE4jUotGAxy4x+u4sWps3jno5W8PO3Q6/jFZ58iISGRxR+v5ZLfXcmd3nU8a8ZU9u7Zw8IPVjDv7Q959un/5UuEJSQYDPLn667ihakzWfjhSl6ZOokvPlubr81Lzz1FQkIC769Yy8W/u5I7b/0LAC888wQAb76/nIkz5nLbTX9i//79FX4OUjnFRCLmnOsR7RgioUuL41if/SOZ3+xgX+5+przzBRndmhbZfvRJLZj89hd56wtXbuanX/ZVRKi+tXzpEpo0bUbjJk2pWrUqp40czWtzZuVr89qcWYw5axwAw04dybsL38I5l6/Ny1Mncfqo0RUWt58sX/pR/j4eNYZXC/Txq3NmcebZoT4eftpI3ln4Js453npjPm3atadd+44A1Kpdm/j4+Ao/h8puxbLQddzI6+NTTx/NvAJ9PG/uLEaPDfVxxqkjWfR26Do2M3bt2klubi67d/9C1SpVOOaYGtE4jUptxbIlNG7ajEaNQ308YuRo5s09tI/P8D4rMkacntfHX3y+ll4n9QWgTt1jqVmzJitXLKvwc4gd3lccRWKJgphIxMzsZwu518xWm9knZjbG2/ecmY0Ia/uCmQ2PXrSll1T7KDZv+TlvPWvLzyTXPrrQtg3rHkOj42qwcNXmigovJnyTk0VySkreev2kZHKys4tsEwgEOKZGTbZt25qvzYxpUzlt1JjIB+xDOdnZ+fo4KTmZnOysQ9okpTQAQn1co2ZNtm3dyvp1X2BmjBoxhL4nduGRB++r0Nj9Iic7i6TksOs4OZmcnPzXcU7OwTbh13HGiJFUr34UHVo0JK1tMy674loSa9Wq0Pj94JucbJKSG+St109KJicnq5A2B/u4Ro0abNu2lbbtOjBv7ixyc3P5KnMjqz5eQfZmfVaXSQwNTcbSXZOnA6lAR6AOsMTM3gH+B1wDvGJmNYEewHkFX2xmE4DQBKsjEgvujgor5KJwuEJawhknNWfGe+vYv7/w/VK4gpUtOLTfC23DwTbLlnxE9epH0rpNu/IPMAb85j42Izc3yIcfvM+Ctz/gyOrVOS1jIB1TO3NS334Ri9ePytLHK5YtIT4+npWfb+LHH3/g1EF96d2nH42aFF19PxyV9DlQZBszzjxnPF9+/hmD+nQnpUFD0rt2Iz6gyq6ExERFzNMTeMk5F3TOfQu8DXRxzr0NHG9mxwJnAdOcc7kFX+yce9w5l+6cS7eqhVedKlrWlp9JqXMwluQ6R5O9dWehbUf1zj8sKaVTPymFrLC/THOys6hXv36RbXJzc/lpx/Z8FYMZ0yarGlaMpOTkfH2cnZVFvfpJh7TJ3vw1EOrjHdtDfZyUlEyPnr2oXacO1atXZ8DAwaxauaJC4/eDpOQUsrPCruOsLOrVy38dJyUdbJN3HSfWYvqUifTtP5AqVapQt+6xdOnWg481bHaI+knJZGd9nbce+qxIKqTNwT7esWMHiYm1CAQC3Pb3+1iwaAlPvzSN7du307RZ8wqNP6YYURuaNLNBZva5ma0zsxsK2f+gmX3sLV+Y2Y8lHTOWErHiaorPAWcD5wNPVUw4Zbf0i285PjmBRsfVoEogjjN6t2DOhxsPadc8OYHEo6uxeO03UYjS3zqlpbNhwzo2ZW5k7969vDxtMqcMyX+X6SlDMpj00nMAzJoxjZ4n9cmrNuzfv5+ZM6Zx6kjNDytKp7QubFgf1sdTJzG4QB8PGpLBxBdCfTzz5Wn0OqkvZka//gP5dPUn7Nq1i9zcXN5b9A4tW7WOxmlUaqmd0/P18YzpkxlYoI8HDslg8ouhPp49Yxon9g5dx8kpDVj0zkKcc+zcuZNlSz6keYuW0TiNSi21czob16/jK6+PX5k2mYGDC/Tx4AymeJ8Vs1+ZTk+vj3ft2sWunaE/ot9+awGB+AAtdB37jpnFA48Bg4E2wFlm1ia8jXPuGudcqnMuFXgUmF7ScWNpaPId4BIzewaoBfQGrvf2PQ18BHzjnFsTnfB+veB+xzX/fptZdwwnPi6OZ+Z/ytqvtvHXc7qy/Mvv8pKy0Se1YMo7Xx7y+gX/GEmLBokcfUQV1j1zPpc+/AYLln9V0adRqQUCAe6+9yHGnDaUYHA/Y8edR6vWbbn7zltJ7ZzGoCHDOPvc8/n9hPGc0LE1iYmJ/N9Tz+e9/oP33iUpKZnGGsYpUiAQ4B/3P8wZpw4lGAwydtx4WrVpy9/vCPXx4KHDOOe8C7jsovGkd2hFQmIi/3v6BQASEhO57Iqr6d+7O2bGgFMGMXDQkCifUeUTCAT4230Pcdbpoev4rHNC1/E/7rqV1E5pnDJkGGPHnc/lE8bTLbU1CYmJ/N+Toev4gosv46rfXcRJ3VJxznHm2efRpl2HKJ9R5RMIBLjr3ocYOzKDYDDImeeMp2XrNtxz12107NSZU4YM46xx53PlJefTo1NrEhJr8e8nQ0nZ1u+/46yRGcTFxVGvfhKP/t+TUT4bv7NoTaw/AVjnnNsAYGYTgRHAp0W0Pwu4paSDWmFj2n5jZj8BNYB7CGWqDrjTOTcprM1rwAzn3H9KOl5czYauWs/rS2omZfDVxEujHULMi4+Lne9iq6z2Bf3/+ekH+2Pg36nKbFCf7qxcscw3HxhxCY1ctV5/isixd8/+/SZgS9imx51zjwOY2ShgkHPuIm99HNDVOXd5weOYWSNgMZDinAsW956+r4iZWW1gmwtllNdzsAoW3qY60Bx4qYLDExERkfIWuTsctzjn0ot610K2FfVXwpnA1JKSMPD5HDEzSwI+AIq8p93M+gOfAY8657ZXVGwiIiISIdGZrL8ZaBC2ngJkF9H2TEpZ/PF1Rcw5lw20KKHNAqBhxUQkIiIiMWoJ0NzMmgBZhJKtsQUbmVlLIJFQoahEvk7ERERE5DAUhYevOudyzexyYB4QDzzpnFtjZrcDS51zM72mZwETXSkn4SsRExERESkF59xcYG6BbTcXWL/11xxTiZiIiIj4h0Xt8RURETtnIiIiIuIzqoiJiIiIv0TpC7ojQYmYiIiI+ErBL7X3Mw1NioiIiESJKmIiIiLiG4YqYiIiIiJSDlQRExEREf8wCv/WR59SRUxEREQkSlQRExERER+xmJojpkRMREREfCWWEjENTYqIiIhEiSpiIiIi4iuqiImIiIhImakiJiIiIr6iipiIiIiIlJkqYiIiIuIfMfZAVyViIiIi4hsWY88R09CkiIiISJSoIiYiIiK+ooqYiIiIiJSZKmIiIiLiK7FUEVMiJiIiIr4SS4mYhiZFREREokQVMREREfGPGHuOmCpiIiIiIlGiipiIiIj4iuaIiYiIiEiZqSImIiIivhFrX3GkRExERER8JZYSMQ1NioiIiESJKmIiIiLiL7FTEFNFTERERCRaVBETERER/7DYmiOmRKwQ7ZrUZfazF0c7jJjWcPBt0Q4h5uXMVx9HWs1q+gitCD/9si/aIcS0GMppfEmfIiIiIuIrqoiJiIiIREksJWKarC8iIiISJaqIiYiIiG/E2pP1VRETERERiRJVxERERMRfYqcgpoqYiIiISLSoIiYiIiL+oQe6ioiIiERPLCViGpoUERERiRJVxERERMRXVBETERERkTJTRUxERET8JXYKYqqIiYiIiESLKmIiIiLiK5ojJiIiIhIFZhaxpRTvPcjMPjezdWZ2QxFtRpvZp2a2xsxeLOmYqoiJiIiIlMDM4oHHgAHAZmCJmc10zn0a1qY5cCNwonPuBzM7tqTjKhETERERX4nS0OQJwDrn3AYvhonACODTsDYXA485534AcM59V9JBNTQpIiIiElLHzJaGLRPC9iUDX4etb/a2hWsBtDCz98xssZkNKukNVRETERERX4lgRWyLcy69qLctZJsrsB4AmgN9gBTgXTNr55z7sag3VEVMREREpGSbgQZh6ylAdiFtXnHO7XPObQQ+J5SYFUmJmIiIiPiLRWgp3hKguZk1MbOqwJnAzAJtZgB9AcysDqGhyg3FHVRDkyIiIuIr0Zis75zLNbPLgXlAPPCkc26Nmd0OLHXOzfT2DTSzT4EgcL1zbmtxx1UiJiIiIlIKzrm5wNwC224O+9kB13pLqSgRExEREf8wPVlfRERERMqBKmIiIiLiGwbEUEFMiZiIiIj4Sem+F9IvNDQpIiIiEiWqiImIiIivxFBBTBUxERERkWhRRUxERER8RXPERERERKTMVBETERER/7DYmiOmRExERER8w4C4uNjJxDQ0KSIiIhIlqoiJiIiIr8TS0KQqYiIiIiJRooqYiIiI+IoeXyEiIiIiZaZErJJb+Mbr9O3agd5d2vKvh+89ZP+H7y9iSN/uND3uaObMnJ5v37mjh9O+aT3OP+v0igrXlwZ0bc7KF69i9cRruO6c3ofsv+eKwSx+6vcsfur3rHrpanJe/Uvevp/fvj1v35S7z67IsH1lweuv0aVjGzq3a8mD9/3jkP179uzhgnFn0bldS/r37s5XmzIB+GpTJvVrHU2vrmn06prGNVf8roIj94/X571Gh7YtadvqeO695+5D9u/Zs4dzxo6hbavj6dWjK5syMwF4Y8F8epyQRnpqe3qckMbCt96s4Mj948358+jeuS0ndGzNIw/cc8j+PXv2cPH4sZzQsTWD+p6Ydx1PnfQifU9Mz1uOq1mNT1Z9XMHRxxDv8RWRWKLBV0OTZnYlcBmw3DkX8//qBYNB/vqnq3lh6hzqJSUzfEBP+g/KoEXL1nltklIacP8/H+fxxx465PUTLr+G3bt28cIzT1Rk2L4SF2c8dO0whl7zFFnf7WDR/y5l9qK1fJb5fV6bPz76at7Pl43sRscW9fPWf9mzj27nP1ahMftNMBjk+muu5OXZr5GUnEK/Xt0YPHQYrVq3yWvz3NNPUjMhkeWrP2falEncetONPPncSwA0btqMdz9cFq3wfSEYDHL1lb9nzqvzSU5JoWe3LmRkDKd1m4N9/PSTT5CYkMiaz9YxedJE/vLnP/H8i5OoXbsOU2fMIikpiTWrVzNs6Cls2JQVxbOpnILBIH/6w1VMeWUuSckpDOzTnVOGZNCy1cE+fuHZp6iZkMhHK9fy8tRJ3HHLn/nv0y8yasxYRo0ZC8Cnaz7h3LNG0b5DarROxfcMDU1G0++AIWVJwswsvhzjiaiPly+hcZNmNGzchKpVqzLstDOY/+rsfG0aNGxE67btiYs79FfZs3dfjjr6mIoK15e6tE5h/eatZGb/wL7cIFMWfEJGz9ZFth/dvwOT56+qwAj9b9nSj2jarBmNmzSlatWqnD5qNHNnz8zX5tU5MznrnHEAjDhtJG8vfBPnXDTC9aUlH31Es2bH06RpqI/PGHMms2e9kq/N7FmvcPa48wA4feQoFr75Bs45Ujt1IikpCYA2bduyZ/du9uzZU+HnUNktX7qEJk0PXsenjRzNa3Nm5Wvz2pxZjDkrdB0PO3Uk7y5865Dr+OWpkzh91OgKi1sqP98kYmb2H6ApMNPM/mJmT5rZEjNbYWYjvDaNzexdM1vuLT287X3M7C0zexH4JIqn8at8k5NN/aSUvPX6Scl8k6O/VMtTUt0abP5ue9561vc7SK5bo9C2DY9LoFH9RBYu35C37YiqARb97zLe/r9LGNar6ATucJaTnU1ycoO89aTkFHKys/O1yQ5rEwgEqFGjJtu2bgXgq8yN9O6WztCBfXn/vXcrLnAfyc7OIiXlYB8nJ6eQlZV1aJsGYX1csyZbvT4+4OXp0+iY2olq1apFPmif+SYni+SU/J/HBa/j8DaBQIBjatRk27b8fTxj2lROGzUm8gHHNMMsMks0+GZo0jl3qZkNAvoC1wJvOucuMLME4CMzWwB8Bwxwzu02s+bAS0C6d4gTgHbOuY2FHd/MJgATAJLDPtCiqpCKQCyVYyuDwrqzqErMGf3bM2PhavbvP7i/xcj7yNn6E42TEnnt4QtYvf5bNmZvi1S4vlRYfx5yHRfR5rh69fnk843Uql2bj5cv4+wxI/lg2Spq1Cg8WT5claaPS2rz6Zo13PTnPzF77uvlH2AM+M19zME2y5Z8RPXqR9K6TbvyD1B8yzcVsQIGAjeY2cfAQuAIoCFQBfivmX0CTAHahL3mo6KSMADn3OPOuXTnXHqt2nUjF/mvUC8pmZzszXnrOdlZHFcvKYoRxZ6s73aQcmzNvPXkujXI3vJToW1HndyeyQvyD0vmbA21zcz+gXdWbCQ1bP6YhCQlJ5OV9XXeenbWZurVr19km9zcXHbs2E5irVpUq1aNWrVrA5DaOY0mTZuy/ssvKi54n0hOTmHz5oN9nJW1OW+4MV+br8P6ePt2atWqBcDmzZsZc8Zp/O/JZ2narFnFBe4j9ZNSyNqc//O44HUc3iY3N5efvOv4gBnTJqsaVk5iabK+XxMxA0Y651K9paFzbi1wDfAt0JFQJaxq2Gt2RiHOMunYKZ2NG9bx1aZM9u7dy6yXpzBg0NBohxVTln6WxfENatOofiJVAvGc0b89c9777JB2zRvUIfGYI1m8+uA/dgnHHEHVKqEph7VrVqd7+4aszfyuwmL3i85pXVi/bh2bMjeyd+9epk+dzOChw/K1GTRkGC89/xwAr7w8jd4n9cXM2PL99wSDQQAyN25gw7p1NG7StMLPobJL79KFdeu+JHNjqI+nTJrI0Izh+doMzRjOC889A8D0aVM5qW8/zIwff/yR04cP5fY7/06PE0+MRvi+0CktnQ0bDl7HL0+bzClDMvK1OWVIBpNeCl3Hs2ZMo+dJffKqZvv372fmjGmcOlLzwyQ/3wxNFjAPuMLMrnDOOTPr5JxbAdQENjvn9pvZeYBvJuYXJhAIcPvdD3LuGcMI7g8yeux5tGjVhvv/fjsdUjszYHAGK5cvZcJ5Y9i+/UcWzJvLg/+4kwXvLQdgVMbJrP/yC3bu/Jmu7Ztxz8P/4aR+A6J8VpVLMLifax6YzawHziM+Lo5n5ixj7cbv+OuFJ7P8s6y8pGz0gA5MeSP/9MJWjery6PUj2O8ccWbc9/y7+e62lJBAIMA9DzzMyOFDCAaDnH3ueFq3acvfbr+F1M7pDMkYxrjxF3DphefRuV1LEhMTeeLZFwHjzux4AAAgAElEQVR4/713+fsdtxIfCBAfF8/9jzyWr8IgIYFAgAcf/ifDhp5CMBjkvPEX0KZtW26/9WY6p6WTMWw44y+4kAvGj6Ntq+NJTKzFcy9MBOA///on69ev4+677uDuu+4AYNarr3PsscdG85QqnUAgwN33PsSY04YSDO5n7LjzaNW6LXffeSupndMYNGQYZ597Pr+fMJ4TOrYmMTGR/3vq+bzXf/DeuyQlJesPiXISS9N0zE93JplZJqFK107gIaAHoepYpnMuw5sXNg3YBbwFXOGcO9rM+gDXOecyCj1wAR1S09zsN96LwBnIAS1H3BntEGJezvzboh1CzDuiiq//1vONn37ZF+0QYtqAk7rx8fJlvslsqie3dK0u+XdEjr3ilpOXOefSS25ZfnxVEXPONQ5bvaSQ/V8CHcI23ehtX0hoLpmIiIhIpeGrRExEREQOb3qgq4iIiIiUC1XERERExFdiqCCmipiIiIhItKgiJiIiIr4SS3PElIiJiIiIr8RQHqahSREREZFoUUVMRERE/MNia2hSFTERERGRKFFFTERERHwj9EDXaEdRflQRExEREYkSVcRERETERyym5ogpERMRERFfiaE8TEOTIiIiItGiipiIiIj4SiwNTaoiJiIiIhIlqoiJiIiIf5jmiImIiIhIOVBFTERERHwj9EDX2CmJKRETERERX4mlRExDkyIiIiJRooqYiIiI+EoMFcRUERMRERGJFiViIiIi4itmFpGlFO87yMw+N7N1ZnZDIfvHm9n3Zvaxt1xU0jE1NCkiIiL+EaXniJlZPPAYMADYDCwxs5nOuU8LNJ3knLu8tMdVRUxERESkZCcA65xzG5xze4GJwIiyHlSJmIiIiPiGEZlhSW9oso6ZLQ1bJoS9dTLwddj6Zm9bQSPNbJWZTTWzBiWdj4YmRUREREK2OOfSi9hX2ICoK7A+C3jJObfHzC4FngH6FfeGqoiJiIiIr5hFZinBZiC8wpUCZIc3cM5tdc7t8Vb/C6SVdFAlYiIiIiIlWwI0N7MmZlYVOBOYGd7AzOqHrQ4H1pZ0UA1NioiIiK/EReG2SedcrpldDswD4oEnnXNrzOx2YKlzbiZwpZkNB3KBbcD4ko6rRExERER8JVpP1nfOzQXmFth2c9jPNwI3/ppjamhSREREJEpUERMRERHfCE2sj50vm1RFTERERCRKVBETERERX4mLnYKYKmIiIiIi0aKKmIiIiPhKLM0RUyJWiPg4o2b1KtEOI6blzL8t2iHEvPr9by65kZTJutnq44pw1BH6pyqSrNBv7qncYigP09CkiIiISLTozwwRERHxDcOfVbyiqCImIiIiEiWqiImIiIiv6PEVIiIiIlJmqoiJiIiIf5jp8RUiIiIi0RJDeZiGJkVERESiRRUxERER8Q0D4mKoJKaKmIiIiEiUqCImIiIivhJDBTFVxERERESiRRUxERER8RU9vkJEREQkCsw0NCkiIiIi5UAVMREREfEVPb5CRERERMpMFTERERHxldiph6kiJiIiIhI1qoiJiIiIr+jxFSIiIiJREPquyWhHUX6KTMTMrEZxL3TO7Sj/cEREREQOH8VVxNYAjvxz4g6sO6BhBOMSEREROZTZ4TE06ZxrUJGBiIiIiBxuSnXXpJmdaWZ/9n5OMbO0yIYlIiIiUrgDX3NU3ks0lJiImdk/gb7AOG/TLuA/kQxKRERE5HBQmrsmezjnOpvZCgDn3DYzqxrhuEREREQKdVjMEQuzz8ziCE3Qx8xqA/sjGpWIiIhIIWLt8RWlmSP2GDANqGtmtwGLgH9ENCoRERGRw0CJFTHn3LNmtgzo7206wzm3OrJhiYiIiBTucBuaBIgH9hEantT3U4qIiIiUg9LcNfkX4CUgCUgBXjSzGyMdmIiIiEhhLEJLNJSmInYOkOac2wVgZncBy4C/RzIwERERkYLMIC6GhiZLM8y4ifwJWwDYEJlwRERERA4fxX3p94OE5oTtAtaY2TxvfSChOydFREREKlwMFcSKHZo8cGfkGmBO2PbFkQtHRERE5PBR3Jd+P1GRgYiIiIiUxmH1+AozawbcBbQBjjiw3TnXIoJxiYiIiMS80kzWfxp4itCdnYOBycDECMYkIiIiUiSzyCzRUJpErLpzbh6Ac269c+4moG9kwxIRERE5lGHEWWSWaChNIrbHQoOx683sUjMbBhwb4bjEs+D110jv2IZO7Vry4H2HfsXnnj17OH/cWXRq15KTe3dn06ZMADZtyqReraPp2TWNnl3TuOaK31Vw5P6x4PXX6NKxDZ2L6eMLxp1F53Yt6d+7O195ffzVpkzq1zqaXl3T6KU+LtaArs1Z+dLVrJ50Lded0/uQ/fdcOYTFT1/O4qcvZ9VL15Dz2k15+35+5468fVP+cU5Fhu0rby14nd4ntOfEtDb886F7D9m/+P13GdSnG43qHsXsV6bn2zflpefomd6WnultmfLScxUVsu/os0IioTQPdL0GOBq4ktBcsZrABZEMSkKCwSDXXXMlM2a/RlJyCn17dWPw0GG0at0mr81zTz9JQkIiK1Z/zrQpk7j1pht56rmXAGjStBmLPlwWrfB9IRgMcv01V/Ky18f9iujjmgmJLA/r4ye9Pm7ctBnvqo+LFRdnPPSHYQy9+imyvtvBov9dxuxFa/ks8/u8Nn98ZG7ez5eN6kbH5kl567/s2Ue38f+s0Jj9JhgMctMfr+LF6XOon5TC0JNPZOCgDFq0ap3XJjmlAQ889l/+758P5nvtDz9s48F77mLOm+9jZgzp250BgzNISEis6NOo1PRZUYlEcRgxEkqsiDnnPnTO/eSc+8o5N845N9w5915FBBcJFuKL78tctvQjmjZrRuMmTalatSojR41m7uyZ+drMnTOTs84ZB8CI00by9sI3cc5FI1xfKtjHpxfSx6+qj8ukS+sU1m/eRmb2D+zLDTLljVVk9GpdZPvR/TswecHKCozQ/z5etoTGTZrRqHHoOh5x+hm8/uqsfG0aNGxMm7btiYvL//H39pvz6dXnZBITa5GQkEivPiez8I3XKzJ8X9BnhURKkQmJmb1sZtOLWso7EDObYWbLzGyNmU3wtv1sZneZ2UozW2xmx3nbm3nrS8zsdjP7Oew413vbV5nZbd62xma21sz+BSwHGpR3/JGQk51NcvLBUJOSU8jJzi6yTSAQoEaNmmzbuhWATZkb6dUtnSED+/L+e+9WXOA+Upo+zi6mj7/K3EjvbukMVR8XKaluDTZ/tz1vPeu7HSTXrVlo24bHJdCofi0WLjv45R1HVA2w6Inf8fbjlzCsmATucJaTk0395JS89XpJyeTkZBfzioO+yc4mKey19ZOS+Sa7dK89nOizonIxs4gspXjfQWb2uZmtM7Mbimk3ysycmaWXdMzihiYreizgAufcNjM7ElhiZtOAo4DFzrm/mNk9wMXAncDDwMPOuZfM7NIDBzCzgUBz4ARCd3nONLPewFdAS+B851yhg/Ne8jcBoEGDhhE7yV+j0L+kClwohbUxM+rVq8/qzzdSq3ZtPl6+jLPHjOSDZauoUaNGpML1paL6r0CjQtscV68+n6iPS1TYh1tRVYIz+rdnxsLV7N9/cH+LkfeSs+UnGicl8tojF7J6w7dszNoWsXh9qTTXcZEv/e2vPZzos0LMLB54DBgAbCaUq8x0zn1aoN0xhKZzfVia4xZZEXPOvVHc8ttPpUhXmtlKQk/ub0AoodoLzPb2LwMaez93B6Z4P78YdoyB3rKCUOWrlXccgE3OuSK/FcA597hzLt05l167Tt2yn005SEpOJivr67z17KzN1K9fv8g2ubm57NixncRatahWrRq1atcGILVzGo2bNmX9l19UXPA+UVgf1/uNfdxEfVyorO+2k3LswQpY8rE1yN6yo9C2o/p3YPL8Vfm25Wz5CYDM7B94Z8VGUpvXL+ylh7X6ScnkZG3OW/8mO4t69UrXT/WTk8kOe21OdhbH1VcfF6TPisolLkJLCU4A1jnnNjjn9hJ6lNeIQtrdAdwD7C7tuUSdmfUB+gPdnXMdCSVSRwD73ME/Q4KUfHOBAX93zqV6y/Fh3xCwMwKhR1TntC6sX7eOzMyN7N27l2lTJzN46LB8bQYPGcZLz4fucnrl5Wn0PqkvZsaW778nGAwCkLlxAxvWraNxk6YVfg6V3YE+3uT18fRC+niQ+rhMln6WxfEptWlUP5EqgXjOOLkDcxZ9dki75g3rkHjMkSxe/VXetoRjjqBqlXgAatesTvf2DVmb+V2Fxe4XHTuns3HDOr7aFLqOX5k+hQGDMkr12pP6DeCdtxbw448/8OOPP/DOWws4qd+ACEfsP/qsqDyMiA5N1jGzpWHLhLC3Tga+Dlvf7G07GJtZJ6CBc242pVSauyYrQk3gB+fcLjNrBXQrof1iYCQwCTgzbPs84A4ze8E597OZJQP7IhJxBQgEAtz7wMOMHD6EYDDIOeeOp3Wbttx1+y106pzOkIxhjBt/AZdceB6d2rUkMTGRJ58NFQjfe+9d/n7HrcQHAsTHxfPAI4+RWKtWlM+o8gkEAtwT1sdne338t9tvITWsjy+98Dw6e338hNfH7xfo4/vVx4UKBvdzzYOzmPXAeOLjjWdmL2ftxu/460Uns/yzrLykbHT/DkxZkL8a1qrRsTz6xxHs3++IizPue/6dfHdbSkggEOCOex7i7FHD2B8MMubs82jZug33/u02OnZKY+DgDD5evpSLxo1h+/YfmP/aXB64+w7e/GAFiYm1uOq6Gxl68okAXH39n0lM1HVckD4rDhtbnHNFzesqbMw+bzzauxHwQWD8r3lDK+0dHWZWzTm359ccvNRBmFUDZhDKLD8H6gK3ArOdc0d7bUYBGc658WbWHHieUKfMASY455K9dlcBF3mH/hk4h1A1bbZzrl1p4unUOd0tfK9UQ7vyG+k+osir3//maIcQ89bNVh9XhKOOqCw1g9jU98SurFi+1DcTA487vp076/6pETn2w6e2XlZUImZm3YFbnXOneOs3Ajjn/u6t1wTWE8o9AOoB24DhzrmlRb1nab5r8gTgCUJVq4Zm1hG4yDl3RWlPrCRegje4kF1Hh7WZChzo+Sygm3POmdmZwNKwdg8TmsxfUKmSMBEREZFCLAGam1kTQnnImcDYAzudc9uBOgfWzWwhcF1xSRiUbmjyESCDUMUK59xKM4v2VxylAf+00IDuj+gBsyIiIoeNuCjU75xzuWZ2OaFpUPHAk865NWZ2O7DUOTez+CMUrjSJWJxzblOB23SDv+XNyotz7l2gYzRjEBERkcOLc24uMLfAtkLnKDjn+pTmmKVJxL72hied9wyNKwDddysiIiIVziy2nnVXmkTsMkLDkw2Bb4EF3jYRERGRCheNoclIKTERc859R/5HRIiIiIhIOSjNXZP/pZCnDTjnJhTSXERERCSiYmhkslRDkwvCfj4COI38T5YVERERkd+gNEOTk8LXzew5YH7EIhIREREpggFxMVQS+y3fNdkEaFTegYiIiIgcbkozR+wHDs4RiyP0uP4bIhmUiIiISFF+SxWpsio2EfOeXN+R0KP8Afa70n45pYiIiEgExNDIZPFJpZd0veycC3qLkjARERGRclKauyY/MrPOzrnlEY9GREREpBhmFlOT9YtMxMws4JzLBXoCF5vZemAnoRsWnHOucwXFKCIiIhKTiquIfQR0Bk6toFhEREREShRDBbFiEzEDcM6tr6BYRERERA4rxSVidc3s2qJ2OuceiEA8IiIiIsU6XL70Ox44Gq8yJiIiIhJtsfZk/eISsRzn3O0VFomIiIjIYabEOWIiIiIilUkMFcSKfaDryRUWhYiIiMhhqMiKmHNuW0UGIiIiIlIiO3wm64uIiIhUOhZDs6di6QvMRURERHxFFTERERHxjdDjK6IdRflRRUxEREQkSlQRExEREV9RRUxEREREykwVMREREfEVi6EnuioRExEREd/QZH0RERERKReqiImIiIh/2OHzXZMiIiIiEkGqiImIiIivxMVQSUwVMREREZEoUUVMREREfCPW7ppUIiYiIiK+EkMjkxqaFBEREYkWVcQK4XDk7nfRDiOmVYnX3wCRlvnqrdEOIeY1PumaaIdwWNjy4aPRDiGm+a+6ZMThu6CLpH8NRURERKJEFTERERHxDcOPVbyiqSImIiIiEiWqiImIiIh/mB5fISIiIhI1erK+iIiIiJSZKmIiIiLiG5qsLyIiIiLlQhUxERER8RXNERMRERGRMlNFTERERHwlhgpiSsRERETEP4zYGs6LpXMRERERiRgzG2Rmn5vZOjO7oZD9l5rZJ2b2sZktMrM2JR1TiZiIiIj4h4GZRWQp9m3N4oHHgMFAG+CsQhKtF51z7Z1zqcA9wAMlnY4SMREREZGSnQCsc85tcM7tBSYCI8IbOOd2hK0eBbiSDqo5YiIiIuIrEZyrX8fMloatP+6ce9z7ORn4OmzfZqDrIbGZ/R64FqgK9CvpDZWIiYiIiIRscc6lF7GvsPzvkIqXc+4x4DEzGwvcBJxX3BsqERMRERHfMKL2QNfNQIOw9RQgu5j2E4F/l3RQzRETERERX7EILSVYAjQ3syZmVhU4E5iZLy6z5mGrQ4EvSzqoKmIiIiIiJXDO5ZrZ5cA8IB540jm3xsxuB5Y652YCl5tZf2Af8AMlDEuCEjERERHxmWg9Wd85NxeYW2DbzWE/X/Vrj6mhSREREZEoUUVMREREfKTkh6/6iSpiIiIiIlGiipiIiIj4Rqx96bcSMREREfEVDU2KiIiISJmpIiYiIiK+Ejv1MFXERERERKJGFTERERHxD4utOWJKxERERMQ3Yu2uyVg6FxERERFfUUVMREREfCWWhiZVERMRERGJElXERERExFdipx6mipiIiIhI1KgiJiIiIr4SQ1PElIiJiIiIf4QeXxE7mZiGJkVERESiRBUxERER8ZVYGppURaySe2P+PLp2akuXDq14+P57Dtm/Z88eLjx3LF06tGJgnx58tSkzb9+a1asY1K8nJ6Z3pNcJqezevbsCI/ePBa+/RlqH1qS2bcED9/7jkP179uxh/Dlnktq2Bf16dWeT18ebNmVyXOJR9OzamZ5dO3P1FZdVcOT+8eaCeZyY1pZuqa159IHCr+MJ48fSLbU1g/udmHcd79u3jysuvYA+3TvRq0t7Hrn/0N+PhAzo0ZqVL/+V1a/cwnXnDzhk/z1/OJ3FE29g8cQbWDXjZnLeOfh7uOuqESyb+hdWTLuJ+/84qiLD9p35816jU7tWdGjdnPvvvfuQ/Xv27OHcs8+kQ+vm9OnZjU2ZmQAsXfIR3bt0onuXTnRLT2XmKy9XcORSWVW6ipiZNQZmO+faRTmUqAsGg/zp2iuZOvNVkpJTGNC7G4OGZNCydZu8Ni888yQJCQksWfUZ06dM4ra//pknnn2R3NxcLrvwPP71v6dp174j27ZupUqVKlE8m8opGAzyh6uvYMaceSQnp9C3Z1eGZAyjVVgfP/v0kyQkJvLxmi+YOnkit/zlBp5+fiIATZo2Y9GHy6MVvi8Eg0Fu/MNVTJ4xl/rJKQzq252BQzJo2epgH7/47FMkJCSy+OO1zJg6iTtv+TOPP/0is2ZMZe+ePSz8YAW7du2id9eOnDpqDA0bNY7eCVVCcXHGQzeMZuhl/yTr2x9Z9ML1zH77Ez7b8E1emz/ePz3v58vOPImOLVMA6NaxCd1Tm9Jl9N8AePOpa+mV1px3l31ZsSfhA8FgkGuvupyZc18nOSWF3j1OYEjGcFqHfV4889QTJCQksGrtl0yZPJG//uUGnn1hIm3atuPdD5YQCAT4JieHbl1SGTJ0GIFApftn2AcM0xwxqQjLl35Ek6bNaNykKVWrVuW0UWN4dc6sfG1enTOLM88eB8Dw00by7sI3cc7x1hvzadOuPe3adwSgVu3axMfHV/g5VHbLlnxE02bNaOL18elnjGHO7Jn52syd/Qpjzz4XgFNPH8XbXh9L6axYtoQmTZvRyOvjU08fzbwC1/G8ubMYPTZ0HWecOpJFb7+Fcw4zY9euneTm5rJ79y9UrVKFY46pEY3TqNS6tGvM+q+3kJm1lX25QabMW05Gnw5Fth89KI3Jry0DwDmoVrUKVasEqFY1QCAQz3fbdlRU6L6ydMlHNG12PE2ahq7lUaPHMGfWK/nazJk1k7PHnQfAaaePYuFbb+Cco3r16nlJ1+7du2PqyfBSNhFLxMzsKDObY2YrzWy1mY0xs5vNbIm3/rh5V6KZpXntPgB+H3aM8WY23cxeM7MvzeyesH0DzewDM1tuZlPM7Ghv+91m9qmZrTKz+7xtZ3jvudLM3onUOZe3nOxsklJS8taTkpPJyc46pE1ySgMAAoEANWrWZNvWraxf9wVmxhkjhtD3xC488uB9FRq7X2RnZ+X1H0BycjI5WSX0cY1QHwNsytxIz25pDBnQl/cXvVtxgftITnYWSckHr+P6ycnk5GTnb5NzsE0gEOCYGjXZtm0rGSNGUr36UXRo0ZC0ts247IprSaxVq0Lj94OkY2uy+dsf8tazvv2B5Lo1C23bsH4ijZJqs3DJ5wB8uGoj7yz9ko3z72Lj639jwftr+XzjtxUSt99kZ2eR0uDgtZycnEJ2gc+L7OwsUsI+L2rWqMlW7/NiyUcfkp7ajq5pHXj4n/9WNawMzCKzREMkr4JBQLZzbiiAmdUE5jvnbvfWnwMygFnAU8AVzrm3zezeAsdJBToBe4DPzexR4BfgJqC/c26nmf0JuNbM/gmcBrRyzjkzS/COcTNwinMuK2xbPmY2AZgAkNKgYTl1QdkUVnUp+FdUUW1yc4N8+MH7zH/7A46sXp3TMwaSmtqZ3n37RSxePypLH9erV581X2RSq3ZtVixfxtmjT2fx8k+oUUMVm3Bl6eMVy5YQHx/Pys838eOPP3DqoL707tOPRk2aRixePypsmKaomu0Zp6Qx442P2b8/1KJpgzq0bHIcx59yEwBz/nMFJ37QjPeWr49UuL5VlmsZoMsJXVn68Wo+W7uWSy4az8BTBnPEEUdEJtgYpsdXlN4nQH8z+4eZ9XLObQf6mtmHZvYJ0A9o6yVoCc65t73XPVfgOG8457Y753YDnwKNgG5AG+A9M/sYOM/bvgPYDfzPzE4HdnnHeA942swuBgodn3POPe6cS3fOpdeuU6ecuqBskpKTyd68OW89OyuLevWTDmmTtflrAHJzc9mxfTuJtWqRlJRMj569qF2nDtWrV6f/wMGsXLmiQuP3g+TklLz+A8jKyqJeUgl9vCPUx9WqVaNW7doAdOqcRpOmzVj35RcVF7xPJCWnkJ118DrOycqiXr36+dskHWyTm5vLTzu2k5hYi+lTJtK3/0CqVKlC3brH0qVbDz5esaxC4/eDrO9+JOW4xLz15OMSyf5+e6FtR52SxuTXluatj+jbkY8+yWTnL3vZ+cte5r23hq7tm0Q8Zj9KTk5h89cHr+WsrM3UL/B5kZycwuawz4vtO7ZTq0AVt1Xr1lQ/6ig+XbM68kFLpRexRMw59wWQRigh+7uZ3Qz8CxjlnGsP/Bc4glByW9yEmz1hPwcJVfGMUHUt1VvaOOcudM7lAicA04BTgde8WC4lVEFrAHxsZrXL8VQjplNaFzasX8emzI3s3buXl6dOYtCQjHxtBg3JYOILodx15svT6HVSX8yMfv0Hsmb1J+zatYvc3FzeX/QOLVu1jsZpVGqd07uwft06Mr0+nj5lEkOGDsvXZsjQ4bz4wrMAzJg+ld5eH2/5/nuCwSAAGzduYP26L2msSs0hUjun57uOZ0yfzMAC1/HAIRlMfjF0Hc+eMY0Te/fBzEhOacCidxbinGPnzp0sW/IhzVu0jMZpVGpL12zi+IZ1aZRUmyqBeM44pTNzFq46pF3zRseSWKM6i1duzNv29Tc/0CvteOLj4wgE4ujVuTmfbfzmkNcKpKV3Yf26L8ncGLqWp06exJCM4fnaDMkYxgvPPQPAy9OnclKffpgZmRs3kpubC8BXmzbx5Ref66aT3ypCw5IxNzRpZknANufc82b2MzDe27XFm881CpjqnPvRzLabWU/n3CLg7FIcfjHwmJkd75xbZ2bVgRQgG6junJtrZouBdV4szZxzHwIfmtkwQgnZ1vI830gIBALcff/DnHHqUPYHg4wdN55Wbdry9ztuJbVzGoOHDuPs8y7gdxeNp0uHViQkJvLfp18AICExkcuuuJoBvbtjZvQ/ZRADBw2J8hlVPoFAgPsefITThw0mGAxyznnn07pNW+66/RY6dU5jSMZwxo2/gAkXnEtq2xYkJtbiyedeBOC9Re/wtztuJRAIEBcfz4OP/uuQv3wl1Md/u++h/2/vzuPsmu8/jr/eySSIIFuRTFQiQhIhe6gtKJHdFppYKqglRS3VllJFKaWqFC1VjbZ+lkRIJJaSqtqqWYilhIiQzRIqSEjM5PP745xwMxnJJLOcnJv302Me7vKdc773mzP3fu7n+z2fw/BDB1JevpzhRx9Lh4478avLLqJrtx4cOGAwRx5zHKedNILdunakSdOm3HTr3wA4/sSRnPH979Fnt65EBMOOOpZOnb9+EfqGqrx8OWf96m7uv/FU6tcTt437N6/MeoefjRzItP++zcTHXwTgiH49Gf3wyhnFsY8+R59eOzDl7p8SBI88/QoP/MuZmsqUlJRw9W9/x8GD+lFeXs4xI46jU6ed+MXFF9K9e08GDh7CscedwPeO+y67dGxP02bNGPXXOwB45uknufqqX9GgQQPq1avHNdfeQIv1ZPbFsqXaOvtL0oHAVcBy4AtgJEmWahgwG5gDvBURF0nqAdxKMpX4MEnWrLOkEUDPiDgt3eYE4NcR8U9J+wG/AjZKd3kBMBkYx1eZtl9HxG2SxgLt08cmAWfGal541+49YtITz9bYWNiqGtT3Cbu17cqnmj4AACAASURBVLNl5Vl3oei16XNW1l3YICx89ndZd6Go7fWtXkybOiU3i6526Nw1rh/9SK1s+8BOW06NiJ61svGvUWsZsYh4mCSoKjSFJGCq2HYq0KXgoYvSx0cBowraDSq4/Q+gVyW77l3J9g+tcsfNzMzM6ojPnTUzM7NcKaaCrg7EzMzMLDcE1CueOMyV9c3MzMyy4oyYmZmZ5UoxTU06I2ZmZmaWEWfEzMzMLFeK6ZrpzoiZmZmZZcQZMTMzM8uVYloj5kDMzMzMcsPlK8zMzMysRjgjZmZmZjmiopqadEbMzMzMLCPOiJmZmVl+yOUrzMzMzKwGOCNmZmZmuVJECTEHYmZmZpYfSfmK4gnFPDVpZmZmlhFnxMzMzCxXiicf5oyYmZmZWWacETMzM7N8KaKUmDNiZmZmZhlxIGZmZma5olr6b437lfpJmiFppqRzK3n+bEn/lfSCpEmStl3TNh2ImZmZWa5ItfOz+n2qPnAD0B/oBAyX1KlCs+eAnhGxCzAGuHJNr8WBmJmZmdma9QZmRsSsiFgG3AkcVNggIh6LiCXp3X8Drde0US/WNzMzs1ypxbX6LSRNKbh/c0TcnN4uBeYUPDcX2HU12zoBeHBNO3QgZmZmZpZYGBE9v+a5yuK/qLShdDTQE+izph06EDMzM7N8yaZ8xVxgm4L7rYH5FRtJ2h84H+gTEUvXtFEHYmZmZpYbgiqd4VgLJgPtJbUF5gHDgCMLG0jqBtwE9IuI96qyUS/WNzMzM1uDiCgDTgMeBl4B7o6IlyVdImlI2uwqoDEwWtLzksavabvOiJmZmVl+VKHURG2JiAeAByo8dmHB7f3XdpvOiJmZmZllxBkxMzMzy5UiutSkM2JmZmZmWXFGzMzMzPKliFJiDsTMzMwsR6p2ge688NSkmZmZWUacETMzM7Ncyap8RW1wRszMzMwsI86ImZmZWW6Iolqr70CsMuXLg0VLvsi6G0WtSaMGWXeh6C2PyLoLRe+9Z67LugsbhBbfuSXrLhS1pbMWZt2FDZoDMTMzM8uXIkqJORAzMzOzXHH5CjMzMzOrNmfEzMzMLFdcvsLMzMzMqs0ZMTMzM8uVIkqIOSNmZmZmlhVnxMzMzCw/iqyiqwMxMzMzyxWXrzAzMzOzanNGzMzMzHJDuHyFmZmZmdUAZ8TMzMwsV4ooIeaMmJmZmVlWnBEzMzOzfCmilJgDMTMzM8sVl68wMzMzs2pzRszMzMxyxeUrzMzMzKzanBEzMzOzXCmihJgzYmZmZmZZcUbMzMzM8qWIUmIOxMzMzCw3hMtXmJmZmVkNcEbMzMzM8kMuX2FmZmZmNcAZMTMzM8uVIkqIOSNmZmZmlhVnxMzMzCxfiigl5kDMzMzMckQuX2FmZmZm1eeMmJmZmeWKy1eYmZmZWbU5I2ZmZma5IYpqrb4DMTMzM8uZIorEPDVpZmZmlhFnxMzMzCxXXL7CzMzMzKrNGTEzMzPLFZevsDrz+D/+zv7f6sK+vTvzh+t+vcrz/3nmSYZ8+1vs0HIzHrz/3i8f/++L0xnafx/67dWDAX16M+G+MXXZ7VyZ9MjD9O62Ez136cBvr75yleeXLl3KCd89kp67dOCAfXbn7bdmf/ncyy+9wIH77cnuPbuwZ++ufP7553XY8/x47NGH2bNnZ3bv1pHfXXPVKs8vXbqUk487it27dWTgt/dkTjrGy5Yt48zvn8h+u3dn/z168vQTj9dxz/Pjkb8/RPddOtJlpx34zVW/WuX5pUuXMuLoYXTZaQf23etbvFVwHAPMefttWrbYnOuuubqOepw/B3RrzfTrD+elG4/gnEO7VNrmsN23Y9p1Q5l67VBGnbXvl49fekxvplx7GFOuPYyhe2xXV122Giapn6QZkmZKOreS5/eWNE1SmaShVdlmLgMxSW0kHbmOv/tpTfentpSXl3PRT87i1jvu4+Enp3H/2NG8PuOVldq0Kt2GK6+7mcGHfmelxzdp1IirbriFh56Yyp/vuo9LL/gRHy/6qC67nwvl5eX8+OwfcPfY+3l6yguMHX0nr77y35Xa/O22W2nSpAlTXniVkaeewcU/+ykAZWVlnHLCsVx97Q08PWU64x+cRIMGDbJ4Geu18vJyfnrOGdw+Zjz/fHY648bcxWuvrnwc3/HXP9OkSROefu4VTvz+D7j0ovMBuP22PwHwj6enced9D3DxBT9h+fLldf4a1nfl5eX88MzTuWfcRCY/9xJjKjmO/zLqVpo0bcr0l1/j1NPP4Ofnr/wZct6Pz+aAvv3qstu5Uq+e+O1Je3DQLx6i2w/GcPie7ejQuslKbdq13JxzDuvCfueNp8cZY/jRrc8A0K/HNnTdrjm7njWWvX88jjMP3oXNNvF7RXWoln5Wu0+pPnAD0B/oBAyX1KlCs7eBEcD/VfW15DIQA9oAlQZikopmunX6tCls27Yd32zTloYNGzLokKE8+tCEldq0/ua2dNhpZ+rVW/mfsm279rTdbnsAttq6Fc1bbMkHHyyss77nxbQp/6Htdu1o03Y7GjZsyCFDv8ODE+9fqc2DE+9n2FHHADDkkMP41z//QUTw2KRH6NR5ZzrvnHwzbta8OfXr16/z17C+e27qZNps145t2yRjfNBhR/DwAyuP8cMP3M/hw5MxHnTQoTz5+GNEBK/NeIW9+iRZhRbf2JItttiC6c9NrfPXsL6bMvk/bNeuHW3T4/iww7/DxAnjV2ozccI4hh/1XQAOPnQo/0yPY4AJ4++jTdvt6NBppzrve170av8N3ljwMbPf/YQvypYz+sk3GNR725XaHH9AB2568L98tHgZAO8vSjLkHbdpyhMvv0P58mDJ0jJenP0hfbttU+evoWgomZqsjZ816A3MjIhZEbEMuBM4qLBBRMyOiBeAKn9jrNNALM1kvSLpj5JelvR3SZtIaifpIUlTJT0hqUPaflRhaq8gm3UFsJek5yWdJWmEpNGS7gf+LqmxpElpevBFSQdV0p313rvvzKdlaemX97duWcq7C+av9XamT5vMF18sY9s2TodXtGD+fEpbt/7yfqvSUhbMn7dKm1atkzfNkpISNt9iCz784APemPkakhh60AD23aMX112z6tSxwTsL5tOq9KsPnZatSlmwYF4lbZJ/h5KSEjbffHM+/PADduq8Cw8/cD9lZWW8PftNXnj+OebPnVun/c+DBfPn0br1V2PcqrSU+fNWPY5bFx7HmyfH8eLFi7nm6qs49/wL67TPedOq2abMXfjVhMq8DxZT2nzTldq0b7UF7VttwT9+OZjHrxjCAd2SY/qFNz/gwO6t2aRhfZpvthF9OrekdYuVf9fWGy0kTSn4OanguVJgTsH9uelj1ZJF9qg9MDwiTpR0N3AYcBxwSkS8LmlX4EZgv9Vs41zgnIgYBCBpBPAtYJeI+DDNih0SER9LagH8W9L4WPH1rxLpYJ8EfPmhm7VKu7uWKxTfe3cBPzz1e1z1uz+ukjWzysdYFcb469qUlZXz7DNP8+jjz7BJo0YcMqgvXbp2p8++qzt0NzyVjh9VG+NhR4/g9Rmv0m+fb9F6m2/Sc9fdqF/irGNF63ocI/HLX1zEqaefQePGjWure0WhsrfeikNav349tm+5BX1/NoHS5o2ZdNkgepxxD5Omz6NH+2/w2BUHsXDRZzw74z3KPMVeTbW2Wn9hRPRci51+bVxRVVkEYm9GxPPp7akk04y7A6ML3jg2WoftPhIRH6a3BfxS0t4k6cFSYCvgna/75Yi4GbgZYOeu3as9sDVh65alLCj4VvvOgnlstXXLKv/+J598zPeOPJSzz/s53Xr2ro0u5l6r0lLmFWRY5s+bx9YtW63SZv7cOZSWtqasrIyPFy2iabNmtGpVyu577kXzFi0AOKBvf16Y/pwDsQpatipl/ryvvkQumL/qGCdt5tJqxRh//DFNmzZDEhdf/lWmcXDfPmzXrn2d9T0vWpW2Zu7cr8Z4/rx5tGy16nE8d+4cSluvGONFNGvWjCmT/8O4e+/hwvPPZdGij1C9emy08cacPPLUun4Z67V5HyymdYuvgtXS5psy/8PFq7T5z4x3KSsP3nrvE16bv4jtW23O1JkLuXLM81w5JvnoG3XWvsyc/3Gd9t9qxFygMFPTGlj7aaoKskiRLC24XQ40Az6KiK4FPx3T58tI+6gkSmu4mu0W/kUcBXwD6BERXYF3gY1r6gXUlV269WD2rJnMeWs2y5YtY8K9Y/j2gQOr9LvLli1j5IhhHHLEUQwYcmgt9zS/uvXoxaw3ZvLW7DdZtmwZ9465i/4DBq3Upt+AQdx5+18BGH/vPezVZ18ksd/+ffnvSy+yZMkSysrKeOrJf7Fjh46V7WaD1rV7T958YyZvp2M87p676dt/5THu238Qo+9IxnjCuLHsufc+SGLJkiUsWZz8aT/+2KOU1C9hB4/xKnr07MWsmTOZnY7xPaPvYsDAwSu1GTBwCHfc/hcA7hs7hj7pcfzwpMd5acYsXpoxi5GnncE5PzrPQVglprz+Ptu33Jxtt9yMBiX1OHzPdkyc/PZKbe5/djZ9dk4C4OabbUT7Vlvw5rufUK+eaLZZkl/ovG0zOrdpxqPPe4p9XYnM1ohNBtpLaiupITAMGL+G31mj9WFh+8fAm5IOj4jRacC1S0RMB2YDPYC7SRbErTjN5BNgs9VscwvgvYj4QtK+wLarabveKikp4edX/IYR3xnC8vJyhh75XXbo0IlrrriEnbt2Z/9+g3jhuSmMHDGMRYs+4h9/f4Brr7yUh56YygPj7mHyM0/y0YcfcM+dyQfcldfdTKedKz/lekNVUlLCr66+lsMPHkh5eTlHHjOCDp124vJfXETX7j3oP3AwRx97PCO/N4Keu3SgSdOm3DLqdgCaNG3KyNPPZP+9v4UkDjiwH337Dcj4Fa1/SkpKuOyq33LkYYMoLy9n2NEj2LFjJ6687GK6dOvOgQMGM/yY4/jBycexe7eONGnajN/fmhyzH7z/HsMPG0S9evXYumUrfnfTrRm/mvVTSUkJV11zHYcM7k95eTnHHHscHTvtxKWX/Jzu3XswYNAQvjvieE46/rt02WkHmjZtxp//WuWTugwoXx6c9cenuf/n/alfT9w2aQavzPkfPxveg2kz32fi5Ld55Lm57N+1NdOuG0r58uCntz3Lh58sZaMG9Xn0siQw/mTJMo6/5jHKl68XEy+2FiKiTNJpwMNAfeDWiHhZ0iXAlIgYL6kXcC/QFBgs6eKIWO1ZMFrNsqkaJ6kNMCEiOqf3zwEaA7cBvwdakgRbd0bEJZK2AsaRZMUmAadHRGNJDYCHgBbAKOB/QM+IOC3dbgvg/nRbzwN7AP0jYrakTyNitYshdu7aPcY98lRNvnSroEkjn7pd25aWeQ1KbWu80frwXbb4bTn8T1l3oagt/edlLP/f7NyUSO3SrUc8+NgztbLt0qYbTV3NGrFaUafvIhExG+hccL/wNLNVCthExLvAbgUPnZc+/gXw7QrNRxX83kKSxfuV9cErUs3MzHLMlfXNzMzMrNqcVzczM7NcqVgCJ8+cETMzMzPLiDNiZmZmli/FkxBzRszMzMwsK86ImZmZWa4UUULMgZiZmZnlRxWr4OeGpybNzMzMMuKMmJmZmeWKy1eYmZmZWbU5I2ZmZmb5UjwJMWfEzMzMzLLijJiZmZnlShElxByImZmZWb64fIWZmZmZVZszYmZmZpYjcvkKMzMzM6s+Z8TMzMwsN4TXiJmZmZlZDXAgZmZmZpYRT02amZlZrnhq0szMzMyqzRkxMzMzyxWXrzAzMzOzanNGzMzMzPJDxbVGzIGYmZmZ5YYorot+e2rSzMzMLCPOiJmZmVm+FFFKzBkxMzMzs4w4I2ZmZma54vIVZmZmZlZtzoiZmZlZrrh8hZmZmVlGiigO89SkmZmZWVacETMzM7N8KaKUmDNiZmZmZhlxRszMzMxyxeUrzMzMzKzanBEzMzOz3BDFVb5CEZF1H9Y7kt4H3sq6H2upBbAw604UOY9x7fMY1z6Pce3L2xhvGxHfyLoTVSXpIZIxrg0LI6JfLW27Ug7EioSkKRHRM+t+FDOPce3zGNc+j3Ht8xjb2vAaMTMzM7OMOBAzMzMzy4gDseJxc9Yd2AB4jGufx7j2eYxrn8fYqsxrxMzMzMwy4oyYmZmZWUYciJmZmZllxIGYmZlZDZCSMqMr/m9WFQ7EioCk7SXtkHU/ipHfWOuWpK2z7kMxqnj8+niuNZ0BIiI8xlZVDsRyTImNgQuBOq0EvCGQpPjqbJadMu3MBkDS7sBYSc2y7ksxKTyO0zEmfJZWjSoIuu6UNBocjFnVORDLsUh8DtwEDJO0Y9Z9KiYFH17DgP+T1NhvrLVD0m7AD4FzI+JDSX5vqiEFx/GpwI2Svplxl4pOQWDbFWgn6S8rHvd7hq2J3+xySlJnSd+W1DIingKeALZKn6ufbe+Kh6R9gZHAwRHxKeCxrR2tgEOAnbPuSDGSNAA4DugbEW9L2sHvEzWjYPlCSUR8AewK9HAwZlXlQCy/BgEHAfek2YTGwFmS6kdEebZdy6/CN0xJDYBNgQ4kH2JERJnfVGuOpFaSNouIscARwBmSBkbE8qz7lmeVHKMbAxOB3ST9AngQeFBSbV04eYNQYfnClpK2TYOxbkA3B2NWFS7omgMr/oDTP+YdgRLg7Yj4RNLhQC+gFOgPHBMREyu8QVgVVFhLswVQFhGL02zC94GJEfH7im1t3Ug6mGRc3wH+C9wK7A38FLgkIu7LsHu5VeE4Hgq8B7wG/CW9fQcwCfgbcEtEPJRVX4uFpB8CBwBNgbsi4jfpF7n/ALMj4pBMO2jrtZKsO2BrVvCmOgj4DfAq0FzSbyJitKQJQAvgC6AvScDgIGEtFYzz2cBeQCNJN0XEWEkBnChp44i4xuNbPZJ2Bs4jOV5/CewP3BARY9Ips8slPQUs9FivnYLj+EfAwcDJEfGOpMERsTR9biDQniQAtrVUIdg9CRgSEX0k/Qm4RFLjiLhE0q7AY5JaAQt8LFtlPDW5HpO0jaQ/prebAWcBwyJiCHALMEBS94j4LCLmRMQIoLekbbPrdb5JGgkMBo4GPgJGSxoREQ8CtwG9JDXJso95VjA9syUwDtgH6A6clGZ4O0TEXcC+EfG+P7jWjaROwKCI2AN4Q9J+pNPr6cknlwBHR8TbGXYzlyoEYVsDU4FjJJ0BNCHJ6p4l6fKIWBYRe0TEfB/L9nWcEVuPRcQcSden6w7ekjQHaANMi4g/S+oI/BgYBiCpB/ANYHFmnc6xNEhYTDKeJwNBUhZkoqTyiPirpEcjwuO77nYkyejOIDl2jwQGR8SbkgYDIyUdHRHvZNnJvKlkqvx/JBndW4FlwObAXpIaAqOApyJiTt33NP8KgrDjSdY1HgpsBOwHXBARL0oaC+wnqUlEfJRdby0PnBFbTxWsC5sO3CLpZWA60ExS17TZeGChpBUB9XskmYSFdd7hnFGiXsH9hmk5kL+Q/F30B34SEY8AfweuSBeVOwhbR5LaA/+RdG1EzAX+mf4cIKkfcDnw+4j4MLte5k+FDM2BknoCjYBjSb5Y3BARRwI/ARpFxMcOwqpH0h4kQdjREbEE+ASYCRyRZsYaAkMdhFlVeLF+Tki6AxhAsqC5IUmwsC9JsDAuy77lUbqG49P09plAO5J1ducDC4GrSQKwpsAOwG8iYn5G3c29dH3jEcB8kgDh9og4Jz3ZZADwOTDBJ5qsO0lnkawJe5Rkzd2JEfFa+twpwKkkSxtezq6X+SRpi4hYlN7emST79WPg7HQqHUkHkUyzf5tkXZ7H2arEgdh6TlK9FafyS7od2AP4DtAWmB8R//IH19qRNAQ4KCJOkHQ0cAIwkGTK7P8i4tz0Q60dyXqP4X5TXXeSNiUpnXB1RNwvqSkwGRgTEeembRpFxBIfy+tGySXOfhsRAyT9GtgOGEpSfqUZ8AfgRxHxUobdzKV0OncAyfvBYqAl8FeS8kE7AqPTzPmK9o3SLJlZlTgQy4EKwdj9QIOI6FfxOVszSc2Bu4AzSKYTziY5jb83ySL9g1ecWZa2//KbsK2b9CzIP5JMkU1NHxtA8u9wfUScl2X/8qhiwCqpA8nU42yScjZDI+Lz9EvHk8BnEfFZJp0tApK2ASaQFM3ula7f3Z5kCUMnkjPVJ2TZR8svrxHLgYhYvmI9U0QMBj6XdOWK5zLtXP4sA8qAnwPXkHzDXVE+YUhELJV0oaQL0/YfZ9PN/JPUVtKmkRQYfhn4m6RG6dP/A34L7Ctpr8w6mUMV1oS1AIiIV4FNgGOAw9Mg7HvAuUA9B2HV9g7JMfw0cJKSKvozgbHAGyTH8aZZdtDyy2dN5sSKYCwNvMYDfdI3g7Ks+5YnaYmESSSB2MUkZ5A9AVwKtJDUh+QsqOFpe6eM14GkA0myYI9LmgVcRDJF9rSkvwOHk0ztbAz4y0QVVQjCTgeGSJoPXEByzdn3gPsk/YtkTd5RPnmneiQdQ5IFO1JSKXAFcCVJNr05SRbyFp/IY+vKU5M5JGkf4L2IcDHGdaCkzlp74HqSekpzgNNIylU0Ac7xWpp1J6kXyaLxB9OHBpOcYHIOyRRwC5LyFVsBvwMOjYhZGXQ1d1Z8GVNyVYJTgDOBC4EPgT+TBAWHA4uAqSsW61vVVTLtuxnwEjA+Ik5XUqPtZ8A2JGUrDvVZqFYdDsRsg5XWXbuL5E31bpKp+kZeE7buJG0EvA68GxG90sd6kCwcbw5cGEmV952AP5GcXTY9sw7nhKTdgc8jYpqkbsBVwOMR8Yt0Dd41JMHujRHxQpZ9LRZpuZVPI2JBGoxNBR6LiJPTachjgUcd7Fp1eY2YbbDSheOHkWRlTo6ILxyErbt08fJmJGeaflPSufDlON9Hsi6sedp8LjDQQViV9QTultQZmEVyDcP9JPWJiPKI+AHQAPheGgzbOkprDO4A/Iqkxt1WEfEJSWmKoZJujYjFEXGjgzCrCc6I2QYv/XD7LCLeyLoveaWkKv6lwFsk046Pk6y/uzIirkzbbB4RPvlhLVQ4Y/oSkrP0hgNvk0xLtiOpyfavtM1WEfFuVv3Nq8rKpkjqDxxFUnrln2lm7CJgBLAryfIQf4BatXmxvm3wvB6seiTtRrJO6YD052bgM5IPrDGS6kfE5Q7C1l5BEHYySXHhMuBOkrMjbwBGAqcouQTXUw7C1k3BCRCnkQS3jUmWLIhkzd02aT2xNsCuHmerSQ7EzKy65gLfB7qS1GfrQnIGX1uSgMGXeakGSbsCPyS5QHpDkpMfbic5K/Jmkot5+2SHapI0kuQkk5NIylKcGxFnSgqgM7Bb+piDMKtRnpo0sxoh6TKS6Zpr01P+zwAOSYtfumJ+Fa0Yq4L/dyM5k/coSSIp+fFXkoC3HzDLY7v2Khnnn5NkGY8luYTRoSSlVeql9QUbRMQXWfbZipMzYmZWU14ETlZyEfrBwOkrTut3oFA1FQLWjUmmeF8Hukg6PyIuAz6T9DTwPrDcY7v2Koxz+7TW3XbAGJLirQdFRFk6VVku6SaSaWGzGudAzMxqygMkdZWGkCzSfybj/uROwVqlk4E9JU0mKeA8GLhHUmuSWmEHk1yOy9Nka6lCUdzTSDK344E3gUHAnWkQNoJkyv0gX8HEapOnJs2sRq244oOnI9eNpBNJTnQ4i+TqBNNJ1tzNIAkM6pNcaNonmVRDeh3OQSRlKvoCmwMdSNbiTQS6ASe6cLbVNmfEzKymlYOnI6uqQoamA7AtMJCkdMIiYCZJ1ua3EXFJZh0tIumliq4nKcj6hqRbSWoKAswHrgWWuq6g1QUXdDWzGuUArOoqBGHfJ7n4/B9JLv80OCL2JrkCwc4k15VsnFlni0hEzCOpw9ZP0rCIWEpSFuR9ks/FZQ7CrK44I2ZmlpEKa8KOI71uoaTewLaSGpCcHTkd+E1EfJpdb4tLRIyVtBS4XBIRcaekUcCmaSV9szrhQMzMLEOSNiGpmH8BsETSKSQZsVLgHyRrl46KiPey62VxioiJkpYDN0sqi4gxgIMwq1NerG9mljFJJwGnAHOA10guFdUCGAfMcxBWuyQdALwRES6Ma3XOgZiZWcYkbUyyDuyNiPhQ0tHA8SQXRv8s296ZWW1yIGZmtp6QVI9krdiZwHCXqDArfl4jZma2/tiY5LI6R0TEK1l3xsxqnzNiZmbrERfCNduwOBAzMzMzy4gLupqZmZllxIGYmZmZWUYciJmZmZllxIGYmZmZWUYciJltoCSVS3pe0kuSRktqVI1t7SNpQnp7iKRzV9O2SXqB67Xdx0WSzqnq4xXajJI0dC321UaSa3iZWa1zIGa24fosIrpGRGdgGckldr6kxFq/R0TE+Ii4YjVNmgBrHYiZmRUjB2JmBvAEsH2aCXpF0o3ANGAbSX0lPSNpWpo5awwgqZ+kVyU9CRy6YkOSRki6Pr29laR7JU1Pf3YHrgDapdm4q9J2P5I0WdILki4u2Nb5kmZIehTYcU0vQtKJ6XamS7qnQpZvf0lPSHpN0qC0fX1JVxXs++TqDqSZ2dpwIGa2gZNUAvQHXkwf2hH4S0R0AxYDFwD7R0R3YApwdnptxD8Cg4G9gK2/ZvPXAY9HRBegO/AycC7JNRW7RsSPJPUF2gO9ga5AD0l7S+oBDAO6kQR6varwcsZGRK90f68AJxQ81wboAwwE/pC+hhOARRHRK93+iZLaVmE/ZmY1wpc4MttwbSLp+fT2E8CfgFbAWxHx7/Tx3YBOwFOSABoCzwAdgDcj4nUASX8DTqpkH/sB3wWIiHJgkaSmFdr0TX+eS+83JgnMNgPujYgl6T7GV+E1dZZ0Kcn0Z2Pg4YLn7o6I5cDrkmalr6EvsEvB+rEt0n2/VoV9mZlVmwMxsw3XZxHRtfCBNNhaXPgQ8EhEDK/QritQU5flEHB5RNxUYR9nrsM+RgEHR8R0SSOAfQqeQDq62gAAATBJREFUq7itSPd9ekQUBmxIarOW+zUzWyeemjSz1fk3sIek7QEkNZK0A/Aq0FZSu7Td8K/5/UnAyPR360vaHPiEJNu1wsPA8QVrz0olbQn8CzhE0iaSNiOZBl2TzYAFkhoAR1V47nBJ9dI+bwfMSPc9Mm2PpB0kbVqF/ZiZ1QhnxMzsa0XE+2lm6Q5JG6UPXxARr0k6CZgoaSHwJNC5kk2cAdws6QSgHBgZEc9IeiotD/Fguk6sI/BMmpH7FDg6IqZJugt4HniLZPp0TX4GPJu2f5GVA74ZwOPAVsApEfG5pFtI1o5NU7Lz94GDqzY6ZmbV54t+m5mZmWXEU5NmZmZmGXEgZmZmZpYRB2JmZmZmGXEgZmZmZpYRB2JmZmZmGXEgZmZmZpYRB2JmZmZmGfl/ELNdLFkeEUAAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 900x540 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "print(\"\\nF1 Score: {:.2f}\".format(f1_score(data_test.Emotion, predictions, average='micro') * 100))\n",
    "\n",
    "# Plot normalized confusion matrix\n",
    "plot_confusion_matrix(data_test.Emotion, predictions, classes=class_names, normalize=True, title='Normalized confusion matrix')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Lets try other inputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Message: My boyfriend didn't turn up after promising that he was coming.\n",
      "Predicted: sadness\n"
     ]
    }
   ],
   "source": [
    "print('Message: {}\\nPredicted: {}'.format(X_test[4], predictions[4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Message: ['delivery was hour late and my pizza was cold!']\n",
      "predicted: anger (0.05 seconds)\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "message = ['delivery was hour late and my pizza was cold!']\n",
    "\n",
    "seq = tokenizer.texts_to_sequences(message)\n",
    "padded = pad_sequences(seq, maxlen=max_seq_len)\n",
    "\n",
    "start_time = time.time()\n",
    "pred = model.predict(padded)\n",
    "\n",
    "print('Message: ' + str(message))\n",
    "print('predicted: {} ({:.2f} seconds)'.format(class_names[np.argmax(pred)], (time.time() - start_time)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Done\n",
    "Save the model for later use 🙃 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creates a HDF5 file 'my_model.h5'\n",
    "model.save('models/biLSTM_w2v.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import load_model\n",
    "predictor = load_model('models/biLSTM_w2v.h5')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
